{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "   #  Regular Grid Variogram in Python for Engineers and Geoscientists \n",
    "\n",
    "## with GSLIB's GAMV Program Converted to Python\n",
    "\n",
    "### Michael Pyrcz, Associate Professor, University of Texas at Austin \n",
    "\n",
    "\n",
    "#### Contacts: [Twitter/@GeostatsGuy](https://twitter.com/geostatsguy) | [GitHub/GeostatsGuy](https://github.com/GeostatsGuy) | [www.michaelpyrcz.com](http://michaelpyrcz.com) | [GoogleScholar](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en&oi=ao) | [Book](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446)\n",
    "\n",
    "This is a tutorial for / demonstration of **Irregularly Sampled Variogram Calculation in Python with GSLIB's GAMV program translated to Python, wrappers and reimplementations of other GSLIB: Geostatistical Library methods** (Deutsch and Journel, 1997). \n",
    "\n",
    "This exercise demonstrates the semivariogram calculation method in Python with wrappers and reimplimentation of GSLIB methods. The steps include:\n",
    "\n",
    "1. generate a 2D model with sequential Gaussian simulation\n",
    "2. sample from the simulation\n",
    "3. calculate and visualize experimental semivariograms\n",
    "\n",
    "To accomplish this I have provide wrappers or reimplementation in Python for the following GSLIB methods:\n",
    "\n",
    "1. sgsim - sequantial Gaussian simulation limited to 2D and unconditional\n",
    "2. hist - histograms plots reimplemented with GSLIB parameters using python methods\n",
    "3. locmap - location maps reimplemented with GSLIB parameters using python methods\n",
    "4. pixelplt - pixel plots reimplemented with GSLIB parameters using python methods\n",
    "5. locpix - my modification of GSLIB to superimpose a location map on a pixel plot reimplemented with GSLIB parameters using Python methods\n",
    "5. affine - affine correction adjust the mean and standard deviation of a feature reimplemented with GSLIB parameters using Python methods\n",
    "\n",
    "I have also started to translate the GSLIB support subfunctions to Python.  Stay tuned.\n",
    "\n",
    "The GSLIB source and executables are available at http://www.statios.com/Quick/gslib.html.  For the reference on using GSLIB check out the User Guide, GSLIB: Geostatistical Software Library and User's Guide by Clayton V. Deutsch and Andre G. Journel.  Overtime, more of the GSLIB programs will be translated to Python and there will be no need to have the executables.  For this workflow you will need sgsim.exe from GSLIB.com for windows and Mac OS executables from https://github.com/GeostatsGuy/GSLIB_MacOS.  \n",
    "\n",
    "I did this to allow people to use these GSLIB functions that are extremely robust in Python. Also this should be a bridge to allow so many familar with GSLIB to work in Python as a kept the parameterization and displays consistent with GSLIB.  The wrappers are simple functions declared below that write the parameter files, run the GSLIB executable in the working directory and load and visualize the output in Python. This will be included on GitHub for anyone to try it out https://github.com/GeostatsGuy/.  \n",
    "\n",
    "This was my first effort to translate the GSLIB Fortran to Python.  It was pretty easy so I'll start translating other critical GSLIB functions.  I've completed NSCORE, DECLUS, GAM and now GAMV as of now.\n",
    "\n",
    "#### Load the required libraries\n",
    "\n",
    "The following code loads the required libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os                                                 # to set current working directory \n",
    "import numpy as np                                        # arrays and matrix math\n",
    "import pandas as pd                                       # DataFrames\n",
    "import matplotlib.pyplot as plt                           # plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you get a package import error, you may have to first install some of these packages. This can usually be accomplished by opening up a command window on Windows and then typing 'python -m pip install [package-name]'. More assistance is available with the respective package docs.  \n",
    "\n",
    "#### Declare functions\n",
    "\n",
    "Here are the wrappers and reimplementations of GSLIB method along with two utilities to load GSLIB's Geo-EAS from data files into DataFrames and 2D Numpy arrays.  These are used in the testing workflow.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Some GeostatsPy Functions - by Michael Pyrcz, maintained at https://git.io/fNgR7.\n",
    "# A set of functions to provide access to GSLIB in Python.\n",
    "# GSLIB executables: nscore.exe, declus.exe, gam.exe, gamv.exe, vmodel.exe, kb2d.exe & sgsim.exe must be in the working directory \n",
    "import pandas as pd\n",
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt                          \n",
    "import random as rand\n",
    "image_type = 'tif'; dpi = 600\n",
    "\n",
    "# utility to convert GSLIB Geo-EAS files to a 1D or 2D numpy ndarray for use with Python methods\n",
    "def GSLIB2ndarray(data_file,kcol,nx,ny): \n",
    "    colArray = []\n",
    "    if ny > 1:\n",
    "        array = np.ndarray(shape=(ny,nx),dtype=float,order='F')\n",
    "    else:\n",
    "        array = np.zeros(nx)    \n",
    "    with open(data_file) as myfile:   # read first two lines\n",
    "        head = [next(myfile) for x in range(2)]\n",
    "        line2 = head[1].split()\n",
    "        ncol = int(line2[0])          # get the number of columns\n",
    "        for icol in range(0, ncol):   # read over the column names\n",
    "            head = [next(myfile) for x in range(1)]\n",
    "            if icol == kcol:\n",
    "                col_name = head[0].split()[0]       \n",
    "        if ny > 1:\n",
    "            for iy in range(0,ny):\n",
    "                for ix in range(0,nx):\n",
    "                    head = [next(myfile) for x in range(1)]\n",
    "                    array[ny-1-iy][ix] = head[0].split()[kcol]\n",
    "        else:\n",
    "            for ix in range(0,nx):\n",
    "                head = [next(myfile) for x in range(1)]\n",
    "                array[ix] = head[0].split()[kcol]\n",
    "    return array,col_name \n",
    "\n",
    "# utility to convert GSLIB Geo-EAS files to a pandas DataFrame for use with Python methods\n",
    "def GSLIB2Dataframe(data_file):\n",
    "    colArray = []\n",
    "    with open(data_file) as myfile:   # read first two lines\n",
    "        head = [next(myfile) for x in range(2)]\n",
    "        line2 = head[1].split()\n",
    "        ncol = int(line2[0])\n",
    "        for icol in range(0, ncol):\n",
    "            head = [next(myfile) for x in range(1)]\n",
    "            colArray.append(head[0].split()[0])\n",
    "        data = np.loadtxt(myfile, skiprows = 0)\n",
    "        df = pd.DataFrame(data)\n",
    "        df.columns = colArray\n",
    "        return df\n",
    "\n",
    "# histogram, reimplemented in Python of GSLIB hist with MatPlotLib methods, displayed and as image file\n",
    "def hist(array,xmin,xmax,log,cumul,bins,weights,xlabel,title,fig_name):\n",
    "    plt.figure(figsize=(8,6))\n",
    "    cs = plt.hist(array, alpha = 0.2, color = 'red', edgecolor = 'black', bins=bins, range = [xmin,xmax], weights = weights, log = log, cumulative = cumul)\n",
    "    plt.title(title)\n",
    "    plt.xlabel(xlabel); plt.ylabel('Frequency')  \n",
    "    plt.savefig(fig_name + '.' + image_type,dpi=dpi)\n",
    "    plt.show()\n",
    "    return\n",
    "\n",
    "# histogram, reimplemented in Python of GSLIB hist with MatPlotLib methods (version for subplots)\n",
    "def hist_st(array,xmin,xmax,log,cumul,bins,weights,xlabel,title):  \n",
    "    cs = plt.hist(array, alpha = 0.2, color = 'red', edgecolor = 'black', bins=bins, range = [xmin,xmax], weights = weights, log = log, cumulative = cumul)\n",
    "    plt.title(title)\n",
    "    plt.xlabel(xlabel); plt.ylabel('Frequency') \n",
    "    return\n",
    "\n",
    "# location map, reimplemention in Python of GSLIB locmap with MatPlotLib methods\n",
    "def locmap(df,xcol,ycol,vcol,xmin,xmax,ymin,ymax,vmin,vmax,title,xlabel,ylabel,vlabel,cmap,fig_name):\n",
    "    ixy = 0 \n",
    "    plt.figure(figsize=(8,6))    \n",
    "    im = plt.scatter(df[xcol],df[ycol],s=None, c=df[vcol], marker=None, cmap=cmap, norm=None, vmin=vmin, vmax=vmax, alpha=0.8, linewidths=0.8, verts=None, edgecolors=\"black\")\n",
    "    plt.title(title)\n",
    "    plt.xlim(xmin,xmax)\n",
    "    plt.ylim(ymin,ymax)    \n",
    "    plt.xlabel(xlabel)\n",
    "    plt.ylabel(ylabel)\n",
    "    cbar = plt.colorbar(im, orientation = 'vertical',ticks=np.linspace(vmin,vmax,10))\n",
    "    cbar.set_label(vlabel, rotation=270, labelpad=20)\n",
    "    plt.savefig(fig_name + '.' + image_type,dpi=dpi)\n",
    "    plt.show()\n",
    "    return im\n",
    "\n",
    "# location map, reimplemention in Python of GSLIB locmap with MatPlotLib methods (version for subplots)\n",
    "def locmap_st(df,xcol,ycol,vcol,xmin,xmax,ymin,ymax,vmin,vmax,title,xlabel,ylabel,vlabel,cmap):\n",
    "    ixy = 0   \n",
    "    im = plt.scatter(df[xcol],df[ycol],s=None, c=df[vcol], marker=None, cmap=cmap, norm=None, vmin=vmin, vmax=vmax, alpha=0.8, linewidths=0.8, verts=None, edgecolors=\"black\")\n",
    "    plt.title(title)\n",
    "    plt.xlim(xmin,xmax)\n",
    "    plt.ylim(ymin,ymax)    \n",
    "    plt.xlabel(xlabel)\n",
    "    plt.ylabel(ylabel)\n",
    "    cbar = plt.colorbar(im, orientation = 'vertical',ticks=np.linspace(vmin,vmax,10))\n",
    "    cbar.set_label(vlabel, rotation=270, labelpad=20)\n",
    "    return im           \n",
    "\n",
    "# pixel plot, reimplemention in Python of GSLIB pixelplt with MatPlotLib methods\n",
    "def pixelplt(array,xmin,xmax,ymin,ymax,step,vmin,vmax,title,xlabel,ylabel,vlabel,cmap,fig_name):\n",
    "    print(str(step))\n",
    "    xx, yy = np.meshgrid(np.arange(xmin, xmax, step),np.arange(ymax, ymin, -1*step))\n",
    "    plt.figure(figsize=(8,6))\n",
    "    im = plt.contourf(xx,yy,array,cmap=cmap,vmin=vmin,vmax=vmax,levels=np.linspace(vmin,vmax,100))\n",
    "    plt.title(title)\n",
    "    plt.xlabel(xlabel)\n",
    "    plt.ylabel(ylabel)\n",
    "    cbar = plt.colorbar(im,orientation = 'vertical',ticks=np.linspace(vmin,vmax,10))\n",
    "    cbar.set_label(vlabel, rotation=270, labelpad=20)\n",
    "    plt.savefig(fig_name + '.' + image_type,dpi=dpi)\n",
    "    plt.show()\n",
    "    return im\n",
    "\n",
    "# pixel plot, reimplemention in Python of GSLIB pixelplt with MatPlotLib methods(version for subplots)\n",
    "def pixelplt_st(array,xmin,xmax,ymin,ymax,step,vmin,vmax,title,xlabel,ylabel,vlabel,cmap):\n",
    "    xx, yy = np.meshgrid(np.arange(xmin, xmax, step),np.arange(ymax, ymin, -1*step))\n",
    "    ixy = 0 \n",
    "    x = [];y = []; v = [] # use dummy since scatter plot controls legend min and max appropriately and contour does not!\n",
    "    cs = plt.contourf(xx,yy,array,cmap=cmap,vmin=vmin,vmax=vmax,levels = np.linspace(vmin,vmax,100))\n",
    "    im = plt.scatter(x,y,s=None, c=v, marker=None,cmap=cmap, vmin=vmin, vmax=vmax, alpha=0.8, linewidths=0.8, verts=None, edgecolors=\"black\")\n",
    "    plt.title(title)\n",
    "    plt.xlabel(xlabel)\n",
    "    plt.ylabel(ylabel)\n",
    "    plt.clim(vmin,vmax)\n",
    "    cbar = plt.colorbar(im, orientation = 'vertical')\n",
    "    cbar.set_label(vlabel, rotation=270, labelpad=20)\n",
    "    return cs\n",
    "\n",
    "# pixel plot and location map, reimplementation in Python of a GSLIB MOD with MatPlotLib methods\n",
    "def locpix(array,xmin,xmax,ymin,ymax,step,vmin,vmax,df,xcol,ycol,vcol,title,xlabel,ylabel,vlabel,cmap,fig_name):\n",
    "    xx, yy = np.meshgrid(np.arange(xmin, xmax, step),np.arange(ymax, ymin, -1*step))\n",
    "    ixy = 0 \n",
    "    plt.figure(figsize=(8,6))\n",
    "    cs = plt.contourf(xx, yy, array, cmap=cmap,vmin=vmin, vmax=vmax,levels = np.linspace(vmin,vmax,100))\n",
    "    im = plt.scatter(df[xcol],df[ycol],s=None, c=df[vcol], marker=None, cmap=cmap, vmin=vmin, vmax=vmax, alpha=0.8, linewidths=0.8, verts=None, edgecolors=\"black\")\n",
    "    plt.title(title)\n",
    "    plt.xlabel(xlabel)\n",
    "    plt.ylabel(ylabel)\n",
    "    plt.xlim(xmin,xmax)\n",
    "    plt.ylim(ymin,ymax)  \n",
    "    cbar = plt.colorbar(orientation = 'vertical')\n",
    "    cbar.set_label(vlabel, rotation=270, labelpad=20)\n",
    "    plt.savefig(fig_name + '.' + image_type,dpi=dpi)\n",
    "    plt.show()\n",
    "    return cs\n",
    "\n",
    "# pixel plot and location map, reimplementation in Python of a GSLIB MOD with MatPlotLib methods(version for subplots)\n",
    "def locpix_st(array,xmin,xmax,ymin,ymax,step,vmin,vmax,df,xcol,ycol,vcol,title,xlabel,ylabel,vlabel,cmap):\n",
    "    xx, yy = np.meshgrid(np.arange(xmin, xmax, step),np.arange(ymax, ymin, -1*step))\n",
    "    ixy = 0 \n",
    "    cs = plt.contourf(xx, yy, array, cmap=cmap,vmin=vmin, vmax=vmax,levels = np.linspace(vmin,vmax,100))\n",
    "    im = plt.scatter(df[xcol],df[ycol],s=None, c=df[vcol], marker=None, cmap=cmap, vmin=vmin, vmax=vmax, alpha=0.8, linewidths=0.8, verts=None, edgecolors=\"black\")\n",
    "    plt.title(title)\n",
    "    plt.xlabel(xlabel)  \n",
    "    plt.ylabel(ylabel)\n",
    "    plt.xlim(xmin,xmax)\n",
    "    plt.ylim(ymin,ymax)\n",
    "    cbar = plt.colorbar(orientation = 'vertical')\n",
    "    cbar.set_label(vlabel, rotation=270, labelpad=20)\n",
    "\n",
    "# affine distribution correction reimplemented in Python with numpy methods \n",
    "def affine(array,tmean,tstdev): \n",
    "    mean = np.average(array)\n",
    "    stdev = np.std(array)  \n",
    "    array = (tstdev/stdev)*(array - mean) + tmean\n",
    "    return(array)   \n",
    "\n",
    "def make_variogram(nug,nst,it1,cc1,azi1,hmaj1,hmin1,it2=1,cc2=0,azi2=0,hmaj2=0,hmin2=0):\n",
    "    if cc2 == 0:\n",
    "        nst = 1\n",
    "    var = dict([('nug', nug), ('nst', nst), ('it1', it1),('cc1', cc1),('azi1', azi1),('hmaj1', hmaj1), ('hmin1', hmin1), \n",
    "      ('it2', it2),('cc2', cc2),('azi2', azi2),('hmaj2', hmaj2), ('hmin2', hmin2)])\n",
    "    if nug + cc1 + cc2 != 1:\n",
    "        print('\\x1b[0;30;41m make_variogram Warning: sill does not sum to 1.0, do not use in simulation \\x1b[0m')\n",
    "    if cc1 < 0 or cc2 < 0 or nug < 0 or hmaj1 < 0 or hmaj2 < 0 or hmin1 < 0 or hmin2 < 0:\n",
    "        print('\\x1b[0;30;41m make_variogram Warning: contributions and ranges must be all positive \\x1b[0m')\n",
    "    if hmaj1 < hmin1 or hmaj2 < hmin2:\n",
    "        print('\\x1b[0;30;41m make_variogram Warning: major range should be greater than minor range \\x1b[0m')\n",
    "    return var    \n",
    "\n",
    "# sequential Gaussian simulation, 2D unconditional wrapper for sgsim from GSLIB (.exe must be in working directory)\n",
    "def GSLIB_sgsim_2d_uncond(nreal,nx,ny,hsiz,seed,var,output_file):\n",
    "    import os\n",
    "    import numpy as np \n",
    "    \n",
    "    nug = var['nug']\n",
    "    nst = var['nst']; it1 = var['it1']; cc1 = var['cc1']; azi1 = var['azi1']; hmaj1 = var['hmaj1']; hmin1 = var['hmin1'] \n",
    "    it2 = var['it2']; cc2 = var['cc2']; azi2 = var['azi2']; hmaj2 = var['hmaj2']; hmin2 = var['hmin2']     \n",
    "    max_range = max(hmaj1,hmaj2) \n",
    "    hmn = hsiz * 0.5   \n",
    "    hctab = int(max_range/hsiz)*2 + 1\n",
    "\n",
    "    sim_array = np.random.rand(nx,ny)\n",
    "\n",
    "    file = open(\"sgsim.par\", \"w\")\n",
    "    file.write(\"              Parameters for SGSIM                                         \\n\")\n",
    "    file.write(\"              ********************                                         \\n\")\n",
    "    file.write(\"                                                                           \\n\")\n",
    "    file.write(\"START OF PARAMETER:                                                        \\n\")\n",
    "    file.write(\"none                          -file with data                              \\n\")\n",
    "    file.write(\"1  2  0  3  5  0              -  columns for X,Y,Z,vr,wt,sec.var.          \\n\")\n",
    "    file.write(\"-1.0e21 1.0e21                -  trimming limits                           \\n\")\n",
    "    file.write(\"0                             -transform the data (0=no, 1=yes)            \\n\")\n",
    "    file.write(\"none.trn                      -  file for output trans table               \\n\")\n",
    "    file.write(\"1                             -  consider ref. dist (0=no, 1=yes)          \\n\")\n",
    "    file.write(\"none.dat                      -  file with ref. dist distribution          \\n\")\n",
    "    file.write(\"1  0                          -  columns for vr and wt                     \\n\")\n",
    "    file.write(\"-4.0    4.0                   -  zmin,zmax(tail extrapolation)             \\n\")\n",
    "    file.write(\"1      -4.0                   -  lower tail option, parameter              \\n\")\n",
    "    file.write(\"1       4.0                   -  upper tail option, parameter              \\n\")\n",
    "    file.write(\"0                             -debugging level: 0,1,2,3                    \\n\")\n",
    "    file.write(\"nonw.dbg                      -file for debugging output                   \\n\")\n",
    "    file.write(str(output_file) + \"           -file for simulation output                  \\n\")\n",
    "    file.write(str(nreal) + \"                 -number of realizations to generate          \\n\")\n",
    "    file.write(str(nx) + \" \" + str(hmn) + \" \" + str(hsiz) + \"                              \\n\")\n",
    "    file.write(str(ny) + \" \" + str(hmn) + \" \" + str(hsiz) + \"                              \\n\")\n",
    "    file.write(\"1 0.0 1.0                     - nz zmn zsiz                                \\n\")\n",
    "    file.write(str(seed) + \"                  -random number seed                          \\n\")\n",
    "    file.write(\"0     8                       -min and max original data for sim           \\n\")\n",
    "    file.write(\"12                            -number of simulated nodes to use            \\n\")\n",
    "    file.write(\"0                             -assign data to nodes (0=no, 1=yes)          \\n\")\n",
    "    file.write(\"1     3                       -multiple grid search (0=no, 1=yes),num      \\n\")\n",
    "    file.write(\"0                             -maximum data per octant (0=not used)        \\n\")\n",
    "    file.write(str(max_range) + \" \" + str(max_range) + \" 1.0 -maximum search  (hmax,hmin,vert) \\n\")\n",
    "    file.write(str(azi1) + \"   0.0   0.0       -angles for search ellipsoid                 \\n\")\n",
    "    file.write(str(hctab) + \" \" + str(hctab) + \" 1 -size of covariance lookup table        \\n\")\n",
    "    file.write(\"0     0.60   1.0              -ktype: 0=SK,1=OK,2=LVM,3=EXDR,4=COLC        \\n\")\n",
    "    file.write(\"none.dat                      -  file with LVM, EXDR, or COLC variable     \\n\")\n",
    "    file.write(\"4                             -  column for secondary variable             \\n\")\n",
    "    file.write(str(nst) + \" \" + str(nug) + \"  -nst, nugget effect                          \\n\")\n",
    "    file.write(str(it1) + \" \" + str(cc1) + \" \" +str(azi1) + \" 0.0 0.0 -it,cc,ang1,ang2,ang3\\n\")\n",
    "    file.write(\" \" + str(hmaj1) + \" \" + str(hmin1) + \" 1.0 - a_hmax, a_hmin, a_vert        \\n\")\n",
    "    file.write(str(it2) + \" \" + str(cc2) + \" \" +str(azi2) + \" 0.0 0.0 -it,cc,ang1,ang2,ang3\\n\")\n",
    "    file.write(\" \" + str(hmaj2) + \" \" + str(hmin2) + \" 1.0 - a_hmax, a_hmin, a_vert        \\n\")  \n",
    "    file.close()\n",
    "\n",
    "    os.system('\"sgsim.exe sgsim.par\"')       \n",
    "    sim_array = GSLIB2ndarray(output_file,0,nx,ny)         \n",
    "    return(sim_array[0])\n",
    "\n",
    "# extract regular spaced samples from a model   \n",
    "def regular_sample(array,xmin,xmax,ymin,ymax,step,mx,my,name):\n",
    "    x = []; y = []; v = []; iix = 0; iiy = 0;\n",
    "    xx, yy = np.meshgrid(np.arange(xmin, xmax, step),np.arange(ymax, ymin, -1*step))\n",
    "    iiy = 0\n",
    "    for iy in range(0,ny):\n",
    "        if iiy >= my:\n",
    "            iix = 0\n",
    "            for ix in range(0,nx):\n",
    "                if iix >= mx:\n",
    "                    x.append(xx[ix,iy]);y.append(yy[ix,iy]); v.append(array[ix,iy])\n",
    "                    iix = 0; iiy = 0\n",
    "                iix = iix + 1\n",
    "        iiy = iiy + 1\n",
    "    df = pd.DataFrame(np.c_[x,y,v],columns=['X', 'Y', name])\n",
    "    return(df)\n",
    "\n",
    "def random_sample(array,xmin,xmax,ymin,ymax,step,nsamp,name):\n",
    "    import random as rand\n",
    "    x = []; y = []; v = []; iix = 0; iiy = 0;\n",
    "    xx, yy = np.meshgrid(np.arange(xmin, xmax, step),np.arange(ymax-1, ymin-1, -1*step))\n",
    "    ny = xx.shape[0]\n",
    "    nx = xx.shape[1]\n",
    "    sample_index = rand.sample(range((nx)*(ny)), nsamp)\n",
    "    for isamp in range(0,nsamp):\n",
    "        iy = int(sample_index[isamp]/ny)\n",
    "        ix = sample_index[isamp] - iy*nx\n",
    "        x.append(xx[iy,ix])\n",
    "        y.append(yy[iy,ix])\n",
    "        v.append(array[iy,ix])\n",
    "    df = pd.DataFrame(np.c_[x,y,v],columns=['X', 'Y', name])\n",
    "    return(df) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's the GAMV program translated to Python. Note: it was simplified to run just one experimental semivariogram at a time (in a simgle direction) and only for 2D datasets. I have applied Numba to speedup the required double loop over the data.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math                       # for trig and constants\n",
    "from numba import jit             # for precompile speed up of loops with NumPy ndarrays\n",
    "# GSLIB's GAMV program (Deutsch and Journel, 1998) converted from the original Fortran to Python \n",
    "# by Michael Pyrcz, the University of Texas at Austin (Jan, 2019)\n",
    "# Note simplified for 2D, semivariogram only and one direction at a time\n",
    "def gamv(df,xcol,ycol,vcol,tmin,tmax,xlag,xltol,nlag,azm,atol,bandwh,isill): \n",
    "# Parameters - consistent with original GSLIB    \n",
    "# df - DataFrame with the spatial data, xcol, ycol, vcol coordinates and property columns\n",
    "# tmin, tmax - property trimming limits\n",
    "# xlag, xltol - lag distance and lag distance tolerance\n",
    "# nlag - number of lags to calculate\n",
    "# azm, atol - azimuth and azimuth tolerance\n",
    "# bandwh - horizontal bandwidth / maximum distance offset orthogonal to azimuth\n",
    "# isill - 1 for standardize sill\n",
    "\n",
    "# Load the data\n",
    "    df_extract = df.loc[(df[vcol] >= tmin) & (df[vcol] <= tmax)]    # trim values outside tmin and tmax\n",
    "    nd = len(df_extract)\n",
    "    x = df_extract[xcol].values\n",
    "    y = df_extract[ycol].values\n",
    "    vr = df_extract[vcol].values\n",
    "\n",
    "# Summary statistics for the data after trimming\n",
    "    avg = vr.mean()\n",
    "    stdev = vr.std()\n",
    "    sills = stdev**2.0\n",
    "    ssq = sills\n",
    "    vrmin = vr.min()\n",
    "    vrmax = vr.max()\n",
    "    #print('Number of Data ' + str(nd) +', Average ' + str(avg) + ' Variance ' + str(sills))\n",
    "\n",
    "# Define the distance tolerance if it isn't already:\n",
    "    if xltol < 0.0: xltol = 0.5 * xlag\n",
    "\n",
    "# Loop over combinatorial of data pairs to calculate the variogram\n",
    "    dis, vario, npp = variogram_loop(x,y,vr,xlag,xltol,nlag,azm,atol,bandwh) \n",
    "\n",
    "# Standardize sill to one by dividing all variogram values by the variance\n",
    "    for il in range(0,nlag+2):\n",
    "        if isill == 1:\n",
    "            vario[il] = vario[il] / sills\n",
    "\n",
    "# Apply 1/2 factor to go from variogram to semivariogram            \n",
    "        vario[il] = 0.5 * vario[il]\n",
    "    \n",
    "# END - return variogram model information\n",
    "    return dis, vario, npp\n",
    "    \n",
    "@jit(nopython=True) # all NumPy array operations included in this function for precompile with NumBa\n",
    "def variogram_loop(x,y,vr,xlag,xltol,nlag,azm,atol,bandwh):\n",
    "    \n",
    "# Allocate the needed memory: \n",
    "    nvarg = 1\n",
    "    mxdlv = nlag + 2 # in gamv the npp etc. arrays go to nlag + 2\n",
    "    dis = np.zeros(mxdlv)\n",
    "    lag = np.zeros(mxdlv)\n",
    "    vario = np.zeros(mxdlv)\n",
    "    hm = np.zeros(mxdlv)\n",
    "    tm = np.zeros(mxdlv)\n",
    "    hv = np.zeros(mxdlv)\n",
    "    npp = np.zeros(mxdlv)\n",
    "    ivtail = np.zeros(nvarg + 2)\n",
    "    ivhead = np.zeros(nvarg + 2)\n",
    "    ivtype = np.ones(nvarg + 2)\n",
    "    ivtail[0] = 0; ivhead[0] = 0; ivtype[0] = 0;\n",
    "    \n",
    "    EPSLON = 1.0e-20\n",
    "    nd = len(x)\n",
    "# The mathematical azimuth is measured counterclockwise from EW and\n",
    "# not clockwise from NS as the conventional azimuth is:\n",
    "    azmuth = (90.0-azm)*math.pi/180.0\n",
    "    uvxazm = math.cos(azmuth)\n",
    "    uvyazm = math.sin(azmuth)\n",
    "    if atol <= 0.0:\n",
    "        csatol = math.cos(45.0*math.pi/180.0)\n",
    "    else:\n",
    "        csatol = math.cos(atol*math.pi/180.0)\n",
    "\n",
    "# Initialize the arrays for each direction, variogram, and lag:\n",
    "    nsiz = nlag+2\n",
    "    dismxs = ((float(nlag) + 0.5 - EPSLON) * xlag) ** 2  \n",
    "    \n",
    "# MAIN LOOP OVER ALL PAIRS:\n",
    "    for i in range(0,nd):\n",
    "        for j in range(0,nd):\n",
    "\n",
    "# Definition of the lag corresponding to the current pair:\n",
    "            dx  = x[j] - x[i]\n",
    "            dy  = y[j] - y[i]\n",
    "            dxs = dx*dx\n",
    "            dys = dy*dy\n",
    "            hs  = dxs + dys\n",
    "            if hs <= dismxs:\n",
    "                if hs < 0.0: \n",
    "                    hs = 0.0\n",
    "                h = np.sqrt(hs)\n",
    "\n",
    "# Determine which lag this is and skip if outside the defined distance\n",
    "# tolerance:            \n",
    "                if h <= EPSLON:\n",
    "                    lagbeg = 0\n",
    "                    lagend = 0\n",
    "                else:\n",
    "                    lagbeg = -1\n",
    "                    lagend = -1\n",
    "                    for ilag in range(1,nlag+1):\n",
    "                        if h >= (xlag*float(ilag-1)-xltol) and h <= (xlag*float(ilag-1)+xltol): # reduced to -1\n",
    "                            if lagbeg < 0: \n",
    "                                lagbeg = ilag \n",
    "                            lagend = ilag \n",
    "                if lagend >= 0: \n",
    "\n",
    "# Definition of the direction corresponding to the current pair. All\n",
    "# directions are considered (overlapping of direction tolerance cones\n",
    "# is allowed):\n",
    "\n",
    "# Check for an acceptable azimuth angle:\n",
    "                    dxy = np.sqrt(max((dxs+dys),0.0))\n",
    "                    if dxy < EPSLON:\n",
    "                        dcazm = 1.0\n",
    "                    else:\n",
    "                        dcazm = (dx*uvxazm+dy*uvyazm)/dxy\n",
    "\n",
    "# Check the horizontal bandwidth criteria (maximum deviation \n",
    "# perpendicular to the specified direction azimuth):\n",
    "                    band = uvxazm*dy - uvyazm*dx\n",
    "                  \n",
    "# Apply all the previous checks at once to avoid a lot of nested if statements\n",
    "                    if (abs(dcazm) >= csatol) and (abs(band) <= bandwh):\n",
    "# Check whether or not an omni-directional variogram is being computed:\n",
    "                        omni = False\n",
    "                        if atol >= 90.0: omni = True\n",
    "\n",
    "# For this variogram, sort out which is the tail and the head value:\n",
    "                        iv = 0  # hardcoded just one varioigram\n",
    "                        it = ivtype[iv]\n",
    "                        if dcazm >= 0.0:\n",
    "                            vrh   = vr[i]\n",
    "                            vrt   = vr[j]\n",
    "                            if omni:\n",
    "                                vrtpr = vr[i]\n",
    "                                vrhpr = vr[j]\n",
    "                        else:\n",
    "                            vrh   = vr[j]\n",
    "                            vrt   = vr[i]\n",
    "                            if omni:\n",
    "                                vrtpr = vr[j]\n",
    "                                vrhpr = vr[i]\n",
    "\n",
    "# Reject this pair on the basis of missing values:\n",
    "\n",
    "# Data was trimmed at the beginning\n",
    "\n",
    "# The Semivariogram (all other types of measures are removed for now)\n",
    "                        for il in range(lagbeg,lagend+1):\n",
    "                            npp[il] = npp[il] + 1\n",
    "                            dis[il] = dis[il] + h\n",
    "                            tm[il]  = tm[il]  + vrt\n",
    "                            hm[il]  = hm[il]  + vrh\n",
    "                            vario[il] = vario[il] + ((vrh-vrt)*(vrh-vrt))\n",
    "                            if(omni):\n",
    "                                npp[il]  = npp[il]  + 1.0\n",
    "                                dis[il] = dis[il] + h\n",
    "                                tm[il]  = tm[il]  + vrtpr\n",
    "                                hm[il]  = hm[il]  + vrhpr\n",
    "                                vario[il] = vario[il] + ((vrhpr-vrtpr)*(vrhpr-vrtpr))\n",
    "                                \n",
    "# Get average values for gam, hm, tm, hv, and tv, then compute\n",
    "# the correct \"variogram\" measure:\n",
    "    for il in range(0,nlag+2):\n",
    "        i = il\n",
    "        if npp[i] > 0:\n",
    "            rnum   = npp[i]\n",
    "            dis[i] = dis[i] / (rnum)\n",
    "            vario[i] = vario[i] / (rnum)\n",
    "            hm[i]  = hm[i]  / (rnum)\n",
    "            tm[i]  = tm[i]  / (rnum)\n",
    "    \n",
    "    return dis, vario, npp\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a simple test of the GAMV code with visualizations to check the results including the gridded data pixelplt, histogram and experimental semivariograms in 4 directions.\n",
    "\n",
    "#### Set the working directory\n",
    "\n",
    "I always like to do this so I don't lose files and to simplify subsequent read and writes (avoid including the full address each time).  Also, in this case make sure to place the required (see above) GSLIB executables in this directory or a location identified in the environmental variable *Path*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(\"c:/PGE337\")                                   # set the working directory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will have to update the part in quotes with your own working directory and the format is different on a Mac (e.g. \"~/PGE\"). \n",
    "\n",
    "##### Make a 2D spatial model\n",
    "\n",
    "The following are the basic parameters for the demonstration.  This includes the number of cells in the 2D regular grid, the cell size (step) and the x and y min and max along with the color scheme.\n",
    "\n",
    "Then we make a single realization of a Gausian distributed feature over the specified 2D grid and then apply affine correction to ensure we have a reasonable mean and spread for our feature's distribution, assumed to be Porosity (e.g. no negative values) while retaining the Gaussian distribution.  Any transform could be applied at this point.  We are keeping this workflow simple. *This is our truth model that we will sample*.\n",
    "\n",
    "The parameters of *GSLIB_sgsim_2d_uncond* are (nreal,nx,ny,hsiz,seed,hrange1,hrange2,azi,output_file).  nreal is the number of realizations, nx and ny are the number of cells in x and y, hsiz is the cell siz, seed is the random number seed, hrange and hrange2 are the variogram ranges in major and minor directions respectively, azi is the azimuth of the primary direction of continuity (0 is aligned with Y axis) and output_file is a GEO_DAS file with the simulated realization.  The ouput is the 2D numpy array of the simulation along with the name of the property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.contour.QuadContourSet at 0x1d93bbc69b0>"
      ]
     },
     "execution_count": 246,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nx = 100; ny = 100; cell_size = 10                               # grid number of cells and cell size\n",
    "xmin = 0.0; ymin = 0.0;                                          # grid origin\n",
    "xmax = xmin + nx * cell_size; ymax = ymin + ny * cell_size       # calculate the extent of model\n",
    "seed = 74073                                                     # random number seed  for stochastic simulation    \n",
    "vario = make_variogram(0.0,nst=1,it1=1,cc1=1.0,azi1=0,hmaj1=500,hmin1=500)\n",
    "mean = 10.0; stdev = 2.0                                         # Porosity mean and standard deviation\n",
    "#cmap = plt.cm.RdYlBu\n",
    "vmin = 4; vmax = 16; cmap = plt.cm.plasma                        # color min and max and using the plasma color map\n",
    "\n",
    "# calculate a stochastic realization with standard normal distribution\n",
    "sim = GSLIB_sgsim_2d_uncond(1,nx,ny,cell_size,seed,vario,\"Por\")\n",
    "sim = affine(sim,mean,stdev)                                     # correct the distribution to a target mean and standard deviation.\n",
    "sampling_ncell = 10                                              # sample every 10th node from the model\n",
    "#samples = regular_sample(sim,xmin,xmax,ymin,ymax,sampling_ncell,30,30,'Realization')\n",
    "#samples_cluster = samples.drop([80,79,78,73,72,71,70,65,64,63,61,57,56,54,53,47,45,42]) # this removes specific rows (samples)\n",
    "#samples_cluster = samples_cluster.reset_index(drop=True)         # we reset and remove the index (it is not sequential anymore)\n",
    "samples = random_sample(sim,xmin,xmax,ymin,ymax,cell_size,100,\"Por\")\n",
    "locpix(sim,xmin,xmax,ymin,ymax,cell_size,vmin,vmax,samples,'X','Y','Por','Porosity Realization and Regular Samples','X(m)','Y(m)','Porosity (%)',cmap,\"Por_Samples\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below I calculate the isotropic, 000 and 090 directional experimental semivariograms from our sample set.  Then the variograms are visualized together on the same variogram plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tmin = -9999.; tmax = 9999.\n",
    "lagiso, varioiso, nppiso = gamv(samples,'X','Y','Por',tmin,tmax,xlag = 100,xltol = 50,nlag = 10,azm = 0,atol = 90.0,bandwh = 9999,isill = 1) \n",
    "lag000, vario000, npp000 = gamv(samples,'X','Y','Por',tmin,tmax,xlag = 100,xltol = 50,nlag = 10,azm = 0,atol = 22.5,bandwh = 9999,isill = 1) \n",
    "lag090, vario090, npp090 = gamv(samples,'X','Y','Por',tmin,tmax,xlag = 100,xltol = 50,nlag = 10,azm = 90,atol = 22.5,bandwh = 9999,isill = 1) \n",
    "\n",
    "plt.subplot(121)\n",
    "locpix_st(sim,xmin,xmax,ymin,ymax,cell_size,vmin,vmax,samples,'X','Y','Por','Porosity Realization and Random Samples','X(m)','Y(m)','Porosity (%)',cmap)\n",
    "\n",
    "plt.subplot(122)\n",
    "plt.scatter(lagiso,varioiso,s=nppiso/len(samples),marker='x',color = 'black',label = 'Iso')\n",
    "plt.scatter(lag000,vario000,s=npp000/len(samples),marker='o',color = 'blue',label = '000')\n",
    "plt.scatter(lag090,vario090,s=npp090/len(samples),marker='o',color = 'green',label = '090')\n",
    "plt.plot([0,1000],[1.0,1.0],color = 'black')\n",
    "plt.xlabel('Lag Distance(m)')\n",
    "plt.ylabel('Semivariogram')\n",
    "plt.title('Iregular Samples Experimental Variograms')\n",
    "plt.ylim(0,1.5)\n",
    "plt.xlim(0,1000)\n",
    "handles, labels = plt.gca().get_legend_handles_labels()\n",
    "plt.gca().legend(handles[::], labels[::])\n",
    "\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=2.0, top=1.0, wspace=0.3, hspace=0.3)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's the gamv program without the numba acceleration, just incase that is helpful.  Warning it is quite slow with more than a couple hundred data samples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "# GSLIB's GAM program (Deutsch and Journel, 1998) converted from the original Fortran to Python \n",
    "# by Michael Pyrcz, the University of Texas at Austin (Jan, 2019)\n",
    "def gamv(df,xcol,ycol,vcol,tmin,tmax,xlag,xltol,nlag,azm,atol,isill): \n",
    "# Parameters - consistent with original GSLIB    \n",
    "# array - 2D gridded data / model\n",
    "# tmin, tmax - property trimming limits\n",
    "# xsiz, ysiz - grid cell extents in x and y directions\n",
    "# ixd, iyd - lag offset in grid cells\n",
    "# nlag - number of lags to calculate\n",
    "# isill - 1 for standardize sill\n",
    "#\n",
    "\n",
    "    nvarg = 1   # for mulitple variograms repeat the program\n",
    "    nxy = nx*ny\n",
    "    mxdlv = nlag + 2 # in gamv the npp etc. arrays go to nlag + 2\n",
    "    dip = 0.0; dtol = 1.0   # hard code for 2D for now\n",
    "    EPSLON = 1.0e-20\n",
    "    bandwh = 1.0e20\n",
    "    bandwd = 1.0e20\n",
    "\n",
    "# Allocate the needed memory:   \n",
    "    dis = np.zeros(mxdlv)\n",
    "    lag = np.zeros(mxdlv)\n",
    "    vario = np.zeros(mxdlv)\n",
    "    hm = np.zeros(mxdlv)\n",
    "    tm = np.zeros(mxdlv)\n",
    "    hv = np.zeros(mxdlv)\n",
    "    npp = np.zeros(mxdlv)\n",
    "    ivtail = np.zeros(nvarg + 2)\n",
    "    ivhead = np.zeros(nvarg + 2)\n",
    "    ivtype = np.ones(nvarg + 2)\n",
    "    ivtail[0] = 0; ivhead[0] = 0; ivtype[0] = 0;\n",
    "\n",
    "# Load the data\n",
    "    df_extract = df.loc[(df[vcol] >= tmin) & (df[vcol] <= tmax)]    # trim values outside tmin and tmax\n",
    "    nd = len(df_extract)\n",
    "    x = df_extract[xcol]\n",
    "    y = df_extract[ycol]\n",
    "    vr = df_extract[vcol]\n",
    "\n",
    "# Summary statistics for the data after trimming\n",
    "    avg = vr.mean()\n",
    "    stdev = vr.std()\n",
    "    sills = stdev**2.0\n",
    "    ssq = sills\n",
    "    vrmin = vr.min()\n",
    "    vrmax = vr.max()\n",
    "    #print('Number of Data ' + str(nd) +', Average ' + str(avg) + ' Variance ' + str(sills))\n",
    "\n",
    "# Define the distance tolerance if it isn't already:\n",
    "    if xltol < 0.0: xltol = 0.5 * xlag\n",
    "\n",
    "# Removed loop over directions\n",
    "        \n",
    "# The mathematical azimuth is measured counterclockwise from EW and\n",
    "# not clockwise from NS as the conventional azimuth is:\n",
    "    azmuth = (90.0-azm)*math.pi/180.0\n",
    "    uvxazm = math.cos(azmuth)\n",
    "    uvyazm = math.sin(azmuth)\n",
    "    if atol <= 0.0:\n",
    "        csatol = math.cos(45.0*math.pi/180.0)\n",
    "    else:\n",
    "        csatol = math.cos(atol*math.pi/180.0)\n",
    "\n",
    "# The declination is measured positive down from vertical (up) rather\n",
    "# than negative down from horizontal:\n",
    "\n",
    "    declin = (90.0-dip)*math.pi/180.0\n",
    "    uvzdec = math.cos(declin)\n",
    "    uvhdec = math.sin(declin)\n",
    "    if dtol <= 0.0:\n",
    "        csdtol = math.cos(45.0*math.pi/180.0)\n",
    "    else:\n",
    "        csdtol = math.cos(dtol*math.pi/180.0)\n",
    "\n",
    "# Initialize the arrays for each direction, variogram, and lag:\n",
    "    nsiz = nlag+2\n",
    "    dismxs = ((float(nlag) + 0.5 - EPSLON) * xlag) ** 2  \n",
    "    \n",
    "# MAIN LOOP OVER ALL PAIRS:\n",
    "\n",
    "    irepo = max(1,min((nd/10),1000))\n",
    "    for i in range(0,nd):\n",
    "#        if((int(i/irepo)*irepo) == i): \n",
    "#            print( '   currently on seed point ' + str(i) + ' of '+ str(nd))\n",
    "        for j in range(0,nd):\n",
    "\n",
    "# Definition of the lag corresponding to the current pair:\n",
    "            dx  = x[j] - x[i]\n",
    "            dy  = y[j] - y[i]\n",
    "            dxs = dx*dx\n",
    "            dys = dy*dy\n",
    "            hs  = dxs + dys\n",
    "            if hs <= dismxs:\n",
    "                if hs < 0.0: \n",
    "                    hs = 0.0\n",
    "                h = np.sqrt(hs)\n",
    "\n",
    "# Determine which lag this is and skip if outside the defined distance\n",
    "# tolerance:         \n",
    "                if h <= EPSLON:\n",
    "                    lagbeg = 0\n",
    "                    lagend = 0\n",
    "                else:\n",
    "                    lagbeg = -1\n",
    "                    lagend = -1\n",
    "                    for ilag in range(1,nlag+1):\n",
    "                        if h >= (xlag*float(ilag-1)-xltol) and h <= (xlag*float(ilag-1)+xltol): # reduced to -1\n",
    "                            if lagbeg < 0: \n",
    "                                lagbeg = ilag \n",
    "                            lagend = ilag \n",
    "                if lagend >= 0: \n",
    "\n",
    "# Definition of the direction corresponding to the current pair. All\n",
    "# directions are considered (overlapping of direction tolerance cones\n",
    "# is allowed):\n",
    "\n",
    "# Check for an acceptable azimuth angle:\n",
    "                    dxy = np.sqrt(max((dxs+dys),0.0))\n",
    "                    if dxy < EPSLON:\n",
    "                        dcazm = 1.0\n",
    "                    else:\n",
    "                        dcazm = (dx*uvxazm+dy*uvyazm)/dxy\n",
    "\n",
    "# Check the horizontal bandwidth criteria (maximum deviation \n",
    "# perpendicular to the specified direction azimuth):\n",
    "                    band = uvxazm*dy - uvyazm*dx\n",
    "                  \n",
    "# Apply all the previous checks at once to avoid a lot of nested if statements\n",
    "                    if (abs(dcazm) >= csatol) and (abs(band) <= bandwh):\n",
    "# Check whether or not an omni-directional variogram is being computed:\n",
    "                        omni = False\n",
    "                        if atol >= 90.0: omni = True\n",
    "\n",
    "# For this variogram, sort out which is the tail and the head value:\n",
    "                        iv = 0  # hardcoded just one varioigram\n",
    "                        it = ivtype[iv]\n",
    "                        if dcazm >= 0.0:\n",
    "                            vrh   = vr[i]\n",
    "                            vrt   = vr[j]\n",
    "                            if omni:\n",
    "                                vrtpr = vr[i]\n",
    "                                vrhpr = vr[j]\n",
    "\n",
    "                        else:\n",
    "                            vrh   = vr[j]\n",
    "                            vrt   = vr[i]\n",
    "                            if omni:\n",
    "                                vrtpr = vr[j]\n",
    "                                vrhpr = vr[i]\n",
    "\n",
    "# Reject this pair on the basis of missing values:\n",
    "\n",
    "# Data was trimmed at the beginning\n",
    "\n",
    "# The Semivariogram:\n",
    "                        for il in range(lagbeg,lagend+1):\n",
    "                            npp[il] = npp[il] + 1\n",
    "                            dis[il] = dis[il] + h\n",
    "                            tm[il]  = tm[il]  + vrt\n",
    "                            hm[il]  = hm[il]  + vrh\n",
    "                            vario[il] = vario[il] + ((vrh-vrt)*(vrh-vrt))\n",
    "                            if(omni):\n",
    "                                npp[il]  = npp[il]  + 1.0\n",
    "                                dis[il] = dis[il] + h\n",
    "                                tm[il]  = tm[il]  + vrtpr\n",
    "                                hm[il]  = hm[il]  + vrhpr\n",
    "                                vario[il] = vario[il] + ((vrhpr-vrtpr)*(vrhpr-vrtpr))\n",
    "\n",
    "\n",
    "# Get average values for gam, hm, tm, hv, and tv, then compute\n",
    "# the correct \"variogram\" measure:\n",
    "\n",
    "    for il in range(0,nlag+2):\n",
    "        i = il\n",
    "        if npp[i] > 0:\n",
    "            rnum   = npp[i]\n",
    "            dis[i] = dis[i] / (rnum)\n",
    "            vario[i] = vario[i] / (rnum)\n",
    "            hm[i]  = hm[i]  / (rnum)\n",
    "            tm[i]  = tm[i]  / (rnum)\n",
    "\n",
    "# Attempt to standardize:\n",
    "\n",
    "            if isill == 1:\n",
    "                vario[i] = vario[i] / sills\n",
    "\n",
    "# semivariogram            \n",
    "            vario[i] = 0.5 * vario[i]\n",
    "    \n",
    "    return dis, vario, npp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I hope you find this code and demonstration useful. I'm always happy to discuss geostatistics, statistical modeling, uncertainty modeling and machine learning,\n",
    "\n",
    "*Michael*\n",
    "\n",
    "**Michael Pyrcz**, Ph.D., P.Eng. Associate Professor The Hildebrand Department of Petroleum and Geosystems Engineering, Bureau of Economic Geology, The Jackson School of Geosciences, The University of Texas at Austin\n",
    "On Twitter I'm the **GeostatsGuy** and on YouTube my lectures are on the channel, **GeostatsGuy Lectures**."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
